/*
 * To change this license header, choose License Headers in Project Properties.
 * To change this template file, choose Tools | Templates
 * and open the template in the editor.
 */
package cn.net.greenet.common.db_service;

import cn.net.greenet.db.HibernateUtil;
import java.io.Serializable;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import org.hibernate.Query;
import org.hibernate.SQLQuery;
import org.hibernate.Session;

/**
 * @author LiuShang
 * @date 2014-11-7 12:11:02
 */
public class HibernateBaseDao<T> {

    /**
     * 查询所有信息方法
     *
     * @param hql 语句 查询条件
     * @param params 别名
     * @param session
     * @return 数据集合
     */
    public List<T> getList(final String hql, final Map<String, Object> params, Session session) {
        @SuppressWarnings({"unchecked", "rawtypes"})
        Query query = session.createQuery(hql);
        where(params, query);
        List<T> list = query.list();
        return list;
    }
    
       /**
     * 查询所有信息方法
     *
     * @param hql 语句 查询条件
     * @param limit 条数
     * @param params 别名
     * @param session
     * @return 数据集合
     */
    public List<T> getListLimit(final String hql,int limit, final Map<String, Object> params, Session session) {
        @SuppressWarnings({"unchecked", "rawtypes"})
        Query query = session.createQuery(hql);
        where(params, query);
         query.setFirstResult(0).setMaxResults(limit).list();
        List<T> list = query.list();
        return list;
    }
    

    public static void main(String[] args) {
        Session session = HibernateUtil.getSessionFactory().openSession();
        HibernateBaseDao b = new HibernateBaseDao();
        String hql = "SELECT log From Messageincominglog AS log WHERE log.messageType=:messageType AND log.dpiendpointbean.id=17 ORDER BY log.time DESC";

        Map<String, Object> params = new HashMap<String, Object>();
        params.put("messageType", "0xc6");

        List list = b.getList(hql, params, session);
        System.out.println("size:" + list.size());
    }
//    /**
//     * 查询前几条信息方法
//     *
//     * @param hql语句
//     * @param 查询条件
//     * @return 数据集合
//     */
//    public List<T> getSubList(final String hql, final Map<String, Object> params) {
//        @SuppressWarnings({"unchecked", "rawtypes"})
//        List<T> list = this.getHibernateTemplate().executeFind(new HibernateCallback() {
//
//            public Object doInHibernate(Session session)
//                    throws HibernateException, SQLException {
//                Query query = session.createQuery(hql);
//                where(params, query);
//                return query.setFirstResult(0).setMaxResults(6).list();
//            }
//        });
//        return list;
//    }
//

    /**
     * 分页显示当前页的记录集合
     *
     * @param hql 语句
     * @param params 查询条件
     * @param session session
     * @param page 传入当前页数
     * @param rows 每页显示几条数据
     * @return 返回查询的当前页集合
     */
    @SuppressWarnings("unchecked")
    public List<T> getPageList(final String hql, final Map<String, Object> params, Session session,
            final int page, final int rows) {
        Query query = session.createQuery(hql);
        where(params, query);
        return query.setFirstResult((page - 1) * rows).setMaxResults(rows).list();
    }

    /**
     * 保存数据方法
     * @param t 传入对象
     * @param session 
     */
    public void save(T t, Session session) {

        session.save(t);

    }

    /**
     * 删除数据方法
     * @param t 传入对象
     * @param session 
     */
    public void delete(T t, Session session) {
        session.delete(t);

    }

    /**
     * 修改数据方法
     * @param t 传入对象
     * @param session 
     */
    public void update(T t, Session session) {
        session.update(t);

    }

    private void where(final Map<String, Object> params, Query query) {
        if (params != null && !params.isEmpty()) {
            for (String key : params.keySet()) {
                query.setParameter(key, params.get(key));
            }
        }
    }

    /**
     * 加载单个数据对象
     *
     * @param clazz 实体类数据对象
     * @param id 对象主键ID
     * @param session session
     * @return 单个数据对象
     */
    @SuppressWarnings({"unchecked", "rawtypes"})
    public T get(Class clazz, Serializable id, Session session) {

        return (T) session.get(clazz, id);
    }

    /**
     * 传人sql语句查询
     *
     * @param sql 高级的非过程化编程语言
     * @param params 
     * @param session 单线程对象
     * @return 返回查询的查询集合
     */

    public List getSqlList(final String sql, final Map<String, Object> params, Session session) {
        @SuppressWarnings({"unchecked", "rawtypes"})
        SQLQuery query = session.createSQLQuery(sql);
        where(params, query);
        return query.list();
    }

    /**
     * 传人sql语句查询
     * @param sql 高级的非过程化编程语言
     * @param params 查询条件
     * @param session 单线程对象
     * @param page 传入当前页数
     * @param rows 每页显示几条数据
     * @return 返回查询的当前页集合
     */
    public List getSqlPageList(final String sql, final Map<String, Object> params, Session session,
            final int page, final int rows) {
        @SuppressWarnings({"unchecked", "rawtypes"})

        SQLQuery query = session.createSQLQuery(sql);

        where(params, query);

        return query.setFirstResult((page - 1) * rows).setMaxResults(rows).list();
    }

    /**
     * 执行原生sql的更新、删除操作
     * 
     * @param sql 高级的非过程化编程语言
     * @param session 单线程对象
     * @return 
     */
    public int updateSql(final String sql,Session session) {
        int num = session.createSQLQuery(sql).executeUpdate();
        session.flush(); //清理缓存，执行批量插入
        session.clear(); //清空缓存中的 对象
        return num;
    }
//
    /**
     * 调用有对象的存储过程
     * @param procedureName
     * @param params
     * @param session
     * @return 
     */
    public List<T> getProcedure(final String procedureName, final Object[] params,Session session) {
        //List list = this.getHibernateTemplate().findByNamedQuery(procedureName);
        @SuppressWarnings({"unchecked", "rawtypes"})
                Query query = session.getNamedQuery(procedureName);
                if (params != null && params.length > 0) {
                    for (int i = 0; i < params.length; i++) {
                        query.setParameter(i, params[i]);
                    }
                }
                return query.list();
    }

    /**
     * 调用无对象的存储过程,得到带对象的List集合，可以转换为Object对象
     *
     * @return
     */
//    public List<Object[]> procedureOListbject(String procedureName, List<Object> params,Session session) {
//
//        CallableStatement stmt = null;
//        ResultSet rs = null;
//
//        List<Object[]> temp = new ArrayList<Object[]>();
//        Object[] tempo;
//        int columnCount;
//
//        try {
//            stmt = this.getSession().connection().prepareCall(procedureName);
//            if (params != null) {
//                int idx = 1;
//                for (Object obj : params) {
//                    if (obj != null) {
//                        stmt.setObject(idx, obj);
//                    } else {
//                        stmt.setNull(idx, Types.NULL);
//                    }
//                    idx++;
//                }
//            }
//
//            rs = stmt.executeQuery();
//            columnCount = rs.getMetaData().getColumnCount();
//
//            while (rs.next()) {
//
//                tempo = new Object[columnCount];
//                for (int i = 0; i < columnCount; i++) {
//                    if (rs.getMetaData().getColumnType(i + 1) == 2005) {
//                        tempo[i] = rs.getString(i + 1);
//                    } else {
//                        tempo[i] = rs.getObject(i + 1);
//                    }
//
//                }
//                temp.add(tempo);
//                tempo = null;
//
//            }
//        } catch (SQLException e) {
//            e.printStackTrace();
//
//        }
//        return temp;
//    }
//
//    /**
//     * 调用无对象的存储过程,得到带Map的List集合，可以转换为Map键值对
//     *
//     * @return
//     */
//    @SuppressWarnings("unchecked")
//    public List<Map<String, Object>> procedureListMap(String procedureName, List<Object> params) {
//
//        CallableStatement stmt = null;
//        ResultSet rs = null;
//
//        List<Map<String, Object>> list = new ArrayList<Map<String, Object>>();
//
//        try {
//            stmt = this.getSession().connection().prepareCall(procedureName);
//            if (params != null) {
//                int idx = 1;
//                for (Object obj : params) {
//                    if (obj != null) {
//                        stmt.setObject(idx, obj);
//                    } else {
//                        stmt.setNull(idx, Types.NULL);
//                    }
//                    idx++;
//                }
//            }
//
//            rs = stmt.executeQuery();
//
//            while (rs.next()) {
//                int colN = rs.getMetaData().getColumnCount();
//                Map<String, Object> map = new CaseInsensitiveMap();//忽略大小写的key
//                for (int i = 1; i <= colN; i++) {
//                    map.put(rs.getMetaData().getColumnName(i), rs.getObject(i));
//                }
//                list.add(map);
//
//            }
//        } catch (SQLException e) {
//            e.printStackTrace();
//
//        }
//        return list;
//    }
//
//    /**
//     * 调用存储过程的増、删、改方法
//     *
//     * @param procString
//     * @param params
//     * @return
//     */
//    public boolean callProcedure(String procString, List<Object> params) {
//        CallableStatement stmt = null;
//        boolean flag = false;
//        try {
//
//            stmt = this.getSession().connection().prepareCall(procString);
//            if (params != null) {
//                int idx = 1;
//                for (Object obj : params) {
//                    if (obj != null) {
//                        stmt.setObject(idx, obj);
//                    } else {
//                        stmt.setNull(idx, Types.NULL);
//                    }
//                    idx++;
//                }
//            }
//            stmt.execute();
//            flag = true;
//        } catch (SQLException e) {
//            e.printStackTrace();
//
//        }
//        return flag;
//    }
}
